package co.gov.medellin.ssti.sub.common.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.PreparedStatement;

//TODO: purge!
public class database {

	public database() {
	}

	public Connection getConnectionWithDriver(String strParUsuario,
			String strParPwd) throws SQLException {
		String strDriver = "oracle.jdbc.driver.OracleDriver";
		String strUrl = "jdbc:oracle:thin:@10.60.3.101:1521:medpru";
		String strUsuario = strParUsuario;
		String strPwd = strParPwd;
		Connection conn = null;

		try {
			// Instancio la clase del driver, su constructor invoca a
			// DriverManager
			// para que lo registre en memoria
			Class.forName(strDriver).newInstance();

			// Creo la conexion
			conn = DriverManager.getConnection(strUrl, strUsuario, strPwd);
		} catch (ClassNotFoundException cnfe) {
			// Esta excepcion lo lanza el m�todo forName(strDriver)
		} catch (InstantiationException ie) {
			// Esta excepcion lo lanza el m�todo newInstance()
		} catch (IllegalAccessException iae) {
			// Al igual que InstantiationException, esta excepcion lo lanza el
			// m�todo newInstance()
		}
		return conn;
	}

	/*
	 * public Connection getConnection() throws SQLException { Connection conn =
	 * null; try { InitialContext initctx = new InitialContext(); DataSource ds
	 * = (DataSource)initctx.lookup("jdbc/ds_tramiper"); conn =
	 * ds.getConnection(); } catch (NamingException e) {
	 * System.out.println("Error getting the connection: " + e.getMessage()); }
	 * 
	 * return conn; } // End getConnection
	 */

	public void closeConnection(Connection con) {
		try {
			if (con != null && !con.isClosed()) {
				con.close();
			}
		} catch (SQLException e) {
			System.err.println("/******** TDSUB - cwsub");
			e.printStackTrace();
			System.err.println("TDSUB - cwsub ********/");
		}
	} // End closeConnection

	/**
	 * M�todo que busca la cantidad de ocurrencias de un caracter en una
	 * cadena
	 * 
	 * @param strToken
	 *            Cadena en que se buscar� el caracter strSearch
	 * @strSearch Caracter a buscar
	 * @return int con la cantidad de ocurrencias en una cadena
	 */
	public int getOcurrencesCount(String strToken, char strSearch) {
		int iStart = 0;
		int icontOcur = 0;
		while (strToken.indexOf(strSearch, iStart) != -1) {
			icontOcur++;
			iStart = strToken.indexOf(strSearch, iStart) + 1;
		}
		return icontOcur;
	}

	/**
	 * Valida que los par�metros enviados a un SQL esten completos y correctos
	 * 
	 * @param String
	 *            strSql instruccion SQL
	 * @param parPrepar
	 *            arreglo con los par�metros del SQL, si el SQL no lleva
	 *            parametros este valor ser�a null
	 * @return PreparedStatement, en caso que haya un problema con los
	 *         par�metros se retornar�a null
	 */
	private PreparedStatement getPstmtWithArguments(String strSql,
			String parPrepar[], Connection conn) throws SQLException {

		PreparedStatement pstmt = conn.prepareStatement(strSql);
		if (parPrepar != null) {
			int iOcurrencesCount = getOcurrencesCount(strSql, '?');
			if (iOcurrencesCount != parPrepar.length) {
				System.err
						.println("Se tiene "
								+ iOcurrencesCount
								+ " ? en el SQL del PreparedStatement  para "
								+ parPrepar.length
								+ " par�metros marcados. No se ejecuto la instruccion.");
			}
			for (int i = 0; i < parPrepar.length; i++) {
				pstmt.setString(i + 1, parPrepar[i]);
			}
		}

		return pstmt;
	}

	/**
	 * Metodo que ejecuta un comando SQL con instrucciones preparadas
	 * 
	 * @param strSql
	 *            Dml (Insert, update, delete) SQL
	 * @param parPrepar
	 *            arreglo que determinan los par�metros marcados de la
	 *            instruccion preparada, su dimension debe ser igual a cuantos ?
	 *            halla en strSql si su valor es null, indica que el SQL no
	 *            tiene parametros
	 * @return cantidad de registros afectados
	 */
	public int execSql(String strSql, String parPrepar[], Connection conn)
			throws SQLException {
		PreparedStatement pstmt = getPstmtWithArguments(strSql, parPrepar, conn);
		return pstmt.executeUpdate();
	}

	/**
	 * Metodo ejecuta una consulta realizada con instrucciones preparadas
	 * 
	 * @param strQuery
	 *            Consulta SQL
	 * @param parPrepar
	 *            arreglo que determinan los par�metros marcados de la
	 *            instruccion preparada, su dimension debe ser igual a cuantos ?
	 *            halla en query, si la consulta no necesita par�metros su
	 *            valor ser�a null
	 * @return CachedRowSetImpl
	 */
	public ResultSet getRecordsRset(String strQuery, String parPrepar[],
			Connection conn) throws SQLException {
		ResultSet rst;
		PreparedStatement pstmt = getPstmtWithArguments(strQuery, parPrepar,
				conn);
		rst = pstmt.executeQuery();
		return rst;
	}

} // End Database class